FrameLib_Threading.h

Go to the documentation of this file.

#ifndef FrameLib_THREADING_H
#define FrameLib_THREADING_H

#ifdef __APPLE__
    
#include <libkern/OSAtomic.h>
#include <pthread.h>
#include <mach/semaphore.h>
#include <mach/task.h>

namespace OS_Specific
{
    // Mac OS specific definitions
    
    typedef volatile int32_t Atomic32;
    
    static inline int32_t increment32(Atomic32 *a) { return OSAtomicIncrement32Barrier(a); }
    static inline int32_t decrement32(Atomic32 *a) { return OSAtomicDecrement32Barrier(a); }
    static inline int32_t add32(Atomic32 *a, int32_t b) { return OSAtomicAdd32Barrier(b, a); }
    static inline bool compareAndSwap32(Atomic32 *loc, int32_t comp, int32_t exch) { return OSAtomicCompareAndSwap32Barrier(comp, exch, loc); }
    
    typedef void * volatile AtomicPtr;
    
    static inline bool compareAndSwapPtr(AtomicPtr *loc, void *comp, void *exch) { return OSAtomicCompareAndSwapPtrBarrier(comp, exch, loc); }
    static inline void *swapPtr(AtomicPtr *loc, void *swap)
    {
        void *ptr = *loc;
        
        while (!compareAndSwapPtr(loc, ptr, swap))
            ptr = *loc;
        
        return ptr;
    }
    
    typedef pthread_t OSThreadType;
    typedef semaphore_t OSSemaphoreType;
    typedef void *OSThreadFunctionType(void *arg);
}

#else
    
    // Windows OS specific definitions
    
#include <windows.h>

namespace OS_Specific
{
    typedef volatile long Atomic32;
    
    static inline long increment32(Atomic32 *a) { return InterlockedIncrement(a); }
    static inline long decrement32(Atomic32 *a) { return InterlockedDecrement(a); }
    static inline long add32(Atomic32 *a, long b) { return InterlockedAdd(a, b); }
    static inline bool compareAndSwap32(Atomic32 *loc, long comp, long exch) { return InterlockedCompareExchange(loc, exch, comp) == comp; }
    
    typedef volatile PVOID AtomicPtr;
    
    static inline bool compareAndSwapPtr(AtomicPtr *loc, void *comp, void *exch) { return InterlockedCompareExchangePointer(loc, exch, comp) == comp; }
    static inline void *swapPtr(AtomicPtr *loc, void *swap) { return InterlockedExchangePointer(loc, swap); }
    
    typedef HANDLE OSThreadType;
    typedef HANDLE OSSemaphoreType;
    typedef DWORD WINAPI OSThreadFunctionType(LPVOID arg);
}

#endif

// An atomic 32 bit integer

class Atomic32
{
    
public:

    Atomic32(int32_t value) : mValue(value) {}
    Atomic32() : mValue(0)  {}
    
    bool compareAndSwap(int32_t comparand, int32_t exchange) { return OS_Specific::compareAndSwap32(&mValue, comparand, exchange); }
    
    int32_t operator = (const int32_t value)
    {
        mValue = value;
        return value;
    }
    
    int32_t operator += (const int32_t& a)      { return OS_Specific::add32(&mValue, a); }
    
    int32_t operator ++ ()                      { return OS_Specific::increment32(&mValue); }
    int32_t operator ++ (int)                   { return operator++() - 1; }
    int32_t operator -- ()                      { return OS_Specific::decrement32(&mValue); }
    int32_t operator -- (int)                   { return operator--() + 1; }
    
private:
    
    // Deleted
    
    Atomic32(const Atomic32&);
    Atomic32& operator=(const Atomic32&);
    
    OS_Specific::Atomic32 mValue;
};


// An atomic pointer

template <class T> class AtomicPtr
{
    
public:
    
    AtomicPtr() { mValue = NULL; }
    
    bool compareAndSwap(T *comparand, T *exchange) { return OS_Specific::compareAndSwapPtr(&mValue, comparand, exchange); }
    T *swap(T *exchange) { return (T *) OS_Specific::swapPtr(&mValue, exchange); }
    T *clear() { return swap(NULL); }
    
private:
    
    // Deleted
    
    AtomicPtr(const AtomicPtr&);
    AtomicPtr& operator=(const AtomicPtr&);
    
    OS_Specific::AtomicPtr mValue;
};


// A spinlock that can be locked, attempted or acquired

class SpinLock
{
    
public:
    
    SpinLock() {}
    ~SpinLock() { acquire(); }
    
    bool attempt() { return mAtomicLock.compareAndSwap(0, 1); }
    void acquire() { while(attempt() == false); }
    void release() { mAtomicLock.compareAndSwap(1, 0); }
    
private:
    
    // Deleted
    
    SpinLock(const SpinLock&);
    SpinLock& operator=(const SpinLock&);
    
    Atomic32 mAtomicLock;
};


// A class for holding a lock using RAII

class SpinLockHolder
{
    
public:
    
    SpinLockHolder(SpinLock *lock) : mLock(lock) { if (mLock) mLock->acquire(); }
    ~SpinLockHolder() { if (mLock) mLock->release(); }
    
    void destroy()
    {
        if (mLock)
            mLock->release();
        mLock = NULL;
    }
    
private:
    
    SpinLock *mLock;
};


// Lightweight joinable thread

class Thread
{
    
    typedef void ThreadFunctionType(void *);
    
public:
    
    enum PriorityLevel {kLowPriority, kMediumPriority, kHighPriority, kAudioPriority};

    Thread(PriorityLevel priority, ThreadFunctionType *threadFunction, void *arg)
    : mInternal(NULL), mPriority(priority), mThreadFunction(threadFunction), mArg(arg), mValid(false)
    {}

    ~Thread();

    void start();
    void join();

private:
    
    // Deleted
    
    Thread(const Thread&);
    Thread& operator=(const Thread&);
    
    // threadStart is a quick OS-style wrapper to call the object which calls the relevant static function
    
    static OS_Specific::OSThreadFunctionType threadStart;
    void call() { mThreadFunction(mArg); }
    
    // Data
    
    OS_Specific::OSThreadType mInternal;
    PriorityLevel mPriority;
    ThreadFunctionType *mThreadFunction;
    void *mArg;
    bool mValid;
};


// Semaphore (note that you should most likely close() before the destructor is called)

class Semaphore
{

public:
    
    Semaphore(long maxCount);
    ~Semaphore();
    
    void close();
    void signal(long n);
    bool wait();
    
private:
    
    // Deleted
    
    Semaphore(const Semaphore&);
    Semaphore& operator=(const Semaphore&);
    
    // Data
    
    OS_Specific::OSSemaphoreType mInternal;
    bool mValid;
};


// A thread that can be triggered from another thread but without any built-in mechanism to check progress

class TriggerableThread
{
    
public:

    TriggerableThread(Thread::PriorityLevel priority) : mThread(priority, threadEntry, this), mSemaphore(1) {}
    virtual ~TriggerableThread() {}
    
    // Start and join
    
    void start() { mThread.start(); }
    void join();
    
    // Trigger the thread to do something

    void signal() { mSemaphore.signal(1); };
    
private:
    
    // Deleted
    
    TriggerableThread(const Thread&);
    TriggerableThread& operator=(const Thread&);
    
    // threadEntry simply calls threadClassEntry which calls the task handler
    
    static void threadEntry(void *thread);
    void threadClassEntry();
    
    // Override this and provide code for the thread's functionality
    
    virtual void doTask() = 0;
    
    // Data
    
    Thread mThread;
    Semaphore mSemaphore;
};


// A thread to delegate tasks to, which can be then be checked for completion

class DelegateThread
{
    
public:

    DelegateThread(Thread::PriorityLevel priority) : mThread(priority, threadEntry, this), mSemaphore(1), mSignaled(false) {}
    virtual ~DelegateThread() {}

    // Start and join

    void start() { mThread.start(); }
    void join();
    
    // Signal the thread to do something if it is not busy (returns true if the thread was signalled, false if busy)
    
    bool signal();
    
    // Wait for thread's completion of a task - returns true  first time after a signal / false for subsequent calls/the thread has not been signalled
    
    bool completed();
    
private:
    
    // Deleted
    
    DelegateThread(const DelegateThread&);
    DelegateThread& operator=(const DelegateThread&);
    
    // threadEntry simply calls threadClassEntry which calls the task handler
    
    static void threadEntry(void *thread);
    void threadClassEntry();
    
    // Override this and provide code for the thread's functionality

    virtual void doTask() = 0;
    
    // Data

    Thread mThread;
    Semaphore mSemaphore;
    
    bool mSignaled;
    Atomic32 mFlag;
};

#endif